package com.example.springboot.service;

import com.example.springboot.entity.Admin;
import com.example.springboot.mapper.AdminMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCrypt;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Service
public class AdminService {
    @Autowired
    private AdminMapper adminMapper;


    // 获取所有管理员信息
    public List<Admin> getAllAdmins() {
        // 从数据库中获取所有管理员
        List<Admin> admins = adminMapper.findAllAdmins();

        if (admins.isEmpty()) {
            throw new IllegalArgumentException("没有管理员信息");
        }

        return admins;
    }


    // 查找管理员
    public Admin getAdminByUsername(String username) {
        return adminMapper.findByUsername(username);
    }

    // 更新管理员信息
    public String updateAdmin(Admin updatedAdmin) {
        // 校验必填字段
        if (updatedAdmin.getUsername() == null || updatedAdmin.getUsername().trim().isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        if (updatedAdmin.getPasswordHash() == null || updatedAdmin.getPasswordHash().trim().isEmpty()) {
            throw new IllegalArgumentException("密码不能为空");
        }
        if (updatedAdmin.getRegion() == null || updatedAdmin.getRegion().trim().isEmpty()) {
            throw new IllegalArgumentException("地区不能为空");
        }

        // 查找管理员是否存在
        Admin existingAdmin = adminMapper.findByUsername(updatedAdmin.getUsername());
        if (existingAdmin == null) {
            throw new IllegalArgumentException("管理员不存在");
        }

        // 设置默认头像地址（如果头像未提供）
        String defaultAvatarUrl = "https://example.com/default-avatar.jpg";
        if (updatedAdmin.getAvatarUrl() == null || updatedAdmin.getAvatarUrl().trim().isEmpty()) {
            updatedAdmin.setAvatarUrl(defaultAvatarUrl);
        }

        // 设置默认角色为 common（如果未提供角色）
        if (updatedAdmin.getRole() == null || updatedAdmin.getRole().trim().isEmpty()) {
            updatedAdmin.setRole("common");
        }

        // 密码加密处理
        if (!BCrypt.checkpw(updatedAdmin.getPasswordHash(), existingAdmin.getPasswordHash())) {
            String hashedPassword = BCrypt.hashpw(updatedAdmin.getPasswordHash(), BCrypt.gensalt());
            updatedAdmin.setPasswordHash(hashedPassword);
        }

        // 执行更新操作
        adminMapper.updateAdmin(updatedAdmin);

        return "管理员信息更新成功";
    }

    // 添加管理员方法
    public void addAdmin(String currentAdminUsername, Admin newAdmin) {
        // 验证当前操作管理员是否存在且是超级管理员
        Admin currentAdmin = adminMapper.findByUsername(currentAdminUsername);
        if (currentAdmin == null || !"super".equalsIgnoreCase(currentAdmin.getRole())) {
            throw new IllegalArgumentException("权限不足，只有超级管理员可以添加管理员账号");
        }

        // 验证新管理员用户名是否已存在
        Admin existingAdmin = adminMapper.findByUsername(newAdmin.getUsername());
        if (existingAdmin != null) {
            throw new IllegalArgumentException("管理员用户名已存在");
        }

        // 检查地区字段是否为空
        if (newAdmin.getRegion() == null || newAdmin.getRegion().trim().isEmpty()) {
            throw new IllegalArgumentException("地区不能为空");
        }

        // 加密新管理员密码
        String hashedPassword = BCrypt.hashpw(newAdmin.getPasswordHash(), BCrypt.gensalt());
        newAdmin.setPasswordHash(hashedPassword);

        // 默认设置新管理员角色为 common
        newAdmin.setRole("common");

        // 设置默认头像地址
        String defaultAvatarUrl = "https://example.com/default-avatar.jpg";
        if (newAdmin.getAvatarUrl() == null || newAdmin.getAvatarUrl().trim().isEmpty()) {
            newAdmin.setAvatarUrl(defaultAvatarUrl);
        }

        // 保存新管理员信息
        adminMapper.insertAdmin(newAdmin);

        // 可选：返回新管理员信息
        System.out.println("新管理员添加成功：" + newAdmin.getUsername());
    }

    // 删除管理员方法
    public String deleteAdmin(String username) {
        // 检查管理员是否存在
        Admin admin = adminMapper.findByUsername(username);
        if (admin == null) {
            throw new IllegalArgumentException("管理员不存在");
        }

        // 删除管理员
        adminMapper.deleteAdmin(username);

        return "管理员删除成功";
    }
    // 修改当前登录管理员的用户名
    // 用于存储管理员验证码及其过期时间
    private Map<String, String> adminVerificationCodes = new HashMap<>();
    private Map<String, Long> adminVerificationCodeTimestamps = new HashMap<>();
    private static final long ADMIN_CODE_EXPIRATION_TIME = TimeUnit.MINUTES.toMillis(60);

    // 修改当前登录管理员的用户名
    public String updateCurrentUsername(String currentUsername, String newUsername) {
        // 查找当前管理员
        Admin currentAdmin = adminMapper.findByUsername(currentUsername);
        if (currentAdmin == null) {
            throw new IllegalArgumentException("当前管理员不存在");
        }

        // 检查新用户名是否已被使用（排除当前用户名的情况）
        if (!currentUsername.equals(newUsername)) {
            Admin existingAdmin = adminMapper.findByUsername(newUsername);
            if (existingAdmin != null) {
                throw new IllegalArgumentException("新用户名已被使用");
            }
        } else {
            return "用户名未发生变化";
        }

        // 使用新的专用方法更新用户名，传入两个 String 参数
        adminMapper.updateAdminUsername(currentUsername, newUsername);

        return "用户名修改成功";
    }

    // 生成并返回管理员密码重置验证码
    public String sendAdminPasswordResetCode(String username) {
        Admin admin = adminMapper.findByUsername(username);
        if (admin == null) {
            throw new IllegalArgumentException("管理员不存在");
        }

        String resetCode = UUID.randomUUID().toString().substring(0, 6);
        String key = username + "admin";
        adminVerificationCodes.put(key, resetCode);
        adminVerificationCodeTimestamps.put(key, System.currentTimeMillis());

        return resetCode;
    }

    // 验证管理员验证码
    private boolean verifyAdminCode(String username, String verificationCode) {
        String key = username + "admin";

        if (!adminVerificationCodes.containsKey(key)) {
            throw new IllegalArgumentException("验证码不存在或已过期");
        }

        String storedCode = adminVerificationCodes.get(key);
        Long timestamp = adminVerificationCodeTimestamps.get(key);
        long currentTime = System.currentTimeMillis();

        if (currentTime - timestamp > ADMIN_CODE_EXPIRATION_TIME) {
            adminVerificationCodes.remove(key);
            adminVerificationCodeTimestamps.remove(key);
            throw new IllegalArgumentException("验证码已过期");
        }

        if (!storedCode.equals(verificationCode)) {
            throw new IllegalArgumentException("验证码错误");
        }

        return true;
    }

    // 修改当前登录管理员的密码（使用验证码验证）
    public String updateCurrentPassword(String currentUsername, String verificationCode, String newPassword) {
        // 验证验证码
        if (!verifyAdminCode(currentUsername, verificationCode)) {
            throw new IllegalArgumentException("验证码无效");
        }

        // 查找当前管理员
        Admin currentAdmin = adminMapper.findByUsername(currentUsername);
        if (currentAdmin == null) {
            throw new IllegalArgumentException("当前管理员不存在");
        }

        // 更新密码
        String hashedPassword = BCrypt.hashpw(newPassword, BCrypt.gensalt());
        currentAdmin.setPasswordHash(hashedPassword);
        adminMapper.updateAdmin(currentAdmin);

        // 清除使用过的验证码
        String key = currentUsername + "admin";
        adminVerificationCodes.remove(key);
        adminVerificationCodeTimestamps.remove(key);

        return "密码修改成功";
    }
}
